Add VFS for Git functional tests workflow - #874
Merged
Matthew John Cheetham (mjcheetham) merged 1 commit intoApr 2, 2026
Merged
Add VFS for Git functional tests workflow#874Matthew John Cheetham (mjcheetham) merged 1 commit into
Matthew John Cheetham (mjcheetham) merged 1 commit into
Conversation
Matthew John Cheetham (mjcheetham)
requested a review
from Johannes Schindelin (dscho)
March 30, 2026 14:53
Johannes Schindelin (dscho)
previously approved these changes
Mar 31, 2026
Johannes Schindelin (dscho)
left a comment
Johannes Schindelin (dscho)
left a comment
Member
There was a problem hiding this comment.
Good thinking. That way, we'll catch bugs that require fixes like #873 much earlier.
Comment on lines
+6
to
+7
| pull_request: | ||
| branches: [ vfs-*, features/* ] |
There was a problem hiding this comment.
Do we want to run this on all PRs? It would add 4.5h overall runtime to an already hefty 8.5h...
Member
Author
There was a problem hiding this comment.
Do we actually care about overall runtime, or just end-to-end/wall clock time? We're in the Microsoft org and overall Actions compute time is not exactly scarce.
Matthew John Cheetham (mjcheetham)
marked this pull request as ready for review
March 31, 2026 14:10
Matthew John Cheetham (mjcheetham)
dismissed
Johannes Schindelin (dscho)’s stale review
March 31, 2026 14:10
The merge-base changed after approval.
Matthew John Cheetham (mjcheetham)
requested a review
from Derrick Stolee (derrickstolee)
March 31, 2026 15:27
Matthew John Cheetham (mjcheetham)
force-pushed
the
vfs-ft-reuse
branch
7 times, most recently
from
April 2, 2026 10:51
0cf5168 to
3620fa1
Compare
Build Git with VFS support using the Git for Windows SDK and package it as a MicrosoftGit artifact with an install.bat that uses robocopy to deploy to 'C:\Program Files\Git'. Find the latest successful VFSForGit build on master and call its reusable functional-tests.yaml workflow, which downloads the GVFS installer and FT executables from that run, and the Git artifact from this run. Requires a VFSFORGIT_TOKEN secret with actions:read on microsoft/VFSForGit for cross-repo artifact downloads.
Matthew John Cheetham (mjcheetham)
force-pushed
the
vfs-ft-reuse
branch
from
April 2, 2026 11:25
3620fa1 to
ec6d2f2
Compare
Matthew John Cheetham (mjcheetham)
enabled auto-merge
April 2, 2026 12:50
Johannes Schindelin (dscho)
approved these changes
Apr 2, 2026
Matthew John Cheetham (mjcheetham)
merged commit Apr 2, 2026
876169f
into
microsoft:vfs-2.53.0
192 of 195 checks passed
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Apr 12, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Apr 17, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Apr 17, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Apr 20, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Apr 20, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Apr 20, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Jun 12, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Jun 12, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
Johannes Schindelin (dscho)
pushed a commit
that referenced
this pull request
Jun 17, 2026
## TL;DR Add a new `vfs-functional-tests.yml` workflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow. ## Why? VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught *after* a release is tagged. By running the FTs here on every push and PR to `vfs-*` branches, we can catch regressions before they ship. This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable `workflow_call` workflow. ## How it works 1. **Build Git** — checks out this repo, builds with the Git for Windows SDK, and packages the result into a `MicrosoftGit` artifact with an `install.bat` that deploys via robocopy to `C:\Program Files\Git`. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use. 2. **Find VFSForGit build** — locates the latest successful VFSForGit CI run on `master` to get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run. 3. **Call reusable workflow** — invokes `microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master`, which handles the full test matrix (2 configs × 2 architectures × 10 slices)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
TL;DR
Add a new
vfs-functional-tests.ymlworkflow that builds Git from this repository and runs the VFS for Git functional tests against it, using VFSForGit's reusable workflow.Why?
VFS for Git functional tests currently only run in the VFSForGit repository, against a tagged microsoft/git release. This means VFS-related regressions in Git are only caught after a release is tagged. By running the FTs here on every push and PR to
vfs-*branches, we can catch regressions before they ship.This is the counterpart to microsoft/VFSForGit#1932, which extracted the functional tests into a reusable
workflow_callworkflow.How it works
Build Git — checks out this repo, builds with the Git for Windows SDK, and packages the result into a
MicrosoftGitartifact with aninstall.batthat deploys via robocopy toC:\Program Files\Git. Both ARM64 and x64 are built and combined into a single artifact for the FTs to install and use.Find VFSForGit build — locates the latest successful VFSForGit CI run on
masterto get the GVFS installer and FT executables. If the build was a 'skipped' build (because an existing run succeeded with that tree) then follow the annotation to the real run.Call reusable workflow — invokes
microsoft/VFSForGit/.github/workflows/functional-tests.yaml@master, which handles the full test matrix (2 configs × 2 architectures × 10 slices)